{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import io\n",
    "import os\n",
    "import platform\n",
    "import pdb\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from matplotlib.pyplot import cm\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from sklearn import preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data=pd.read_csv('toronto.csv')\n",
    "data.replace(9999,np.nan,inplace=True)\n",
    "data.replace(-999,np.nan,inplace=True)\n",
    "for i in range(len(data)):\n",
    "    for j in range(len(data.columns)):\n",
    "        if np.isnan(data.iat[i,j]):\n",
    "            if i==0:\n",
    "                data.iloc[i,j]=data.iat[i+1,j]\n",
    "            elif i==len(data)-1:\n",
    "                data.iloc[i,j]=data.iat[i-1,j]\n",
    "            else:\n",
    "                data.iloc[i,j]=np.nanmean([data.iat[i-1,j],data.iat[i+1,j]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data.fillna(np.mean(data),inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Temp (°C)</th>\n",
       "      <th>Dew Point Temp (°C)</th>\n",
       "      <th>Rel Hum (%)</th>\n",
       "      <th>Wind Dir (10s deg)</th>\n",
       "      <th>Wind Spd (km/h)</th>\n",
       "      <th>Visibility (km)</th>\n",
       "      <th>Stn Press (kPa)</th>\n",
       "      <th>Wind Chill</th>\n",
       "      <th>NO</th>\n",
       "      <th>NO2</th>\n",
       "      <th>NOx</th>\n",
       "      <th>O3</th>\n",
       "      <th>PM25</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-6.2</td>\n",
       "      <td>-13.2</td>\n",
       "      <td>58.0</td>\n",
       "      <td>25.0</td>\n",
       "      <td>43.0</td>\n",
       "      <td>16.1</td>\n",
       "      <td>100.68</td>\n",
       "      <td>-16.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>19.0</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-6.0</td>\n",
       "      <td>-13.7</td>\n",
       "      <td>55.0</td>\n",
       "      <td>24.0</td>\n",
       "      <td>41.0</td>\n",
       "      <td>16.1</td>\n",
       "      <td>100.59</td>\n",
       "      <td>-16.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>14.0</td>\n",
       "      <td>16.0</td>\n",
       "      <td>19.0</td>\n",
       "      <td>7.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-6.2</td>\n",
       "      <td>-13.3</td>\n",
       "      <td>57.0</td>\n",
       "      <td>24.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>16.1</td>\n",
       "      <td>100.56</td>\n",
       "      <td>-16.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>7.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-6.0</td>\n",
       "      <td>-12.0</td>\n",
       "      <td>63.0</td>\n",
       "      <td>24.0</td>\n",
       "      <td>32.0</td>\n",
       "      <td>16.1</td>\n",
       "      <td>100.58</td>\n",
       "      <td>-15.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>21.0</td>\n",
       "      <td>7.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-6.0</td>\n",
       "      <td>-12.2</td>\n",
       "      <td>62.0</td>\n",
       "      <td>24.0</td>\n",
       "      <td>35.0</td>\n",
       "      <td>16.1</td>\n",
       "      <td>100.50</td>\n",
       "      <td>-15.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>13.0</td>\n",
       "      <td>19.0</td>\n",
       "      <td>7.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Temp (°C)  Dew Point Temp (°C)  Rel Hum (%)  Wind Dir (10s deg)  \\\n",
       "0       -6.2                -13.2         58.0                25.0   \n",
       "1       -6.0                -13.7         55.0                24.0   \n",
       "2       -6.2                -13.3         57.0                24.0   \n",
       "3       -6.0                -12.0         63.0                24.0   \n",
       "4       -6.0                -12.2         62.0                24.0   \n",
       "\n",
       "   Wind Spd (km/h)  Visibility (km)  Stn Press (kPa)  Wind Chill   NO   NO2  \\\n",
       "0             43.0             16.1           100.68       -16.0  3.0  15.0   \n",
       "1             41.0             16.1           100.59       -16.0  2.0  14.0   \n",
       "2             45.0             16.1           100.56       -16.0  1.0  10.0   \n",
       "3             32.0             16.1           100.58       -15.0  1.0  10.0   \n",
       "4             35.0             16.1           100.50       -15.0  2.0  11.0   \n",
       "\n",
       "    NOx    O3  PM25  \n",
       "0  18.0  19.0   6.0  \n",
       "1  16.0  19.0   7.0  \n",
       "2  11.0  22.0   7.0  \n",
       "3  11.0  21.0   7.0  \n",
       "4  13.0  19.0   7.0  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset=pd.DataFrame(data,columns=data.columns[:])\n",
    "split=round(0.90*len(dataset))\n",
    "data1=dataset.iloc[:split].copy()\n",
    "test_set=dataset.iloc[split:].copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler = preprocessing.MinMaxScaler() \n",
    "data1 = scaler.fit_transform(data1)\n",
    "test_set1=scaler.transform(test_set)\n",
    "# dataset.loc[:,:] = scaled_values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data_set=np.asarray(dataset,dtype=np.float32)\n",
    "seq_len=30 + 1\n",
    "x=len(data1)-seq_len\n",
    "y=len(test_set)-seq_len\n",
    "sequences = [np.asarray(data1[t:t+seq_len]) for t in range(x)]\n",
    "test_seq=[np.asarray(test_set[t:t+seq_len]) for t in range(y)]\n",
    "test_seq1=[np.asarray(test_set1[t:t+seq_len]) for t in range(y)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(test_seq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq=torch.FloatTensor(np.asarray(sequences))\n",
    "test_seq=torch.FloatTensor(np.asarray(test_seq))\n",
    "test_seq1=torch.FloatTensor(test_seq1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([845, 31, 13])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_seq.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "split_row=round(0.80*seq.size(0))\n",
    "x_train_set=seq[:split_row, :-1]\n",
    "y_train_set=seq[:split_row, -1:]\n",
    "x_valid_set=seq[split_row:, :-1]\n",
    "y_valid_set=seq[split_row:, -1:]\n",
    "x_test_set=test_seq1[:,:-1]\n",
    "y_test_set=test_seq[:,-1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LSTM(nn.Module):\n",
    "    def __init__(self,input_size,hidden_size,num_layers=2,dropout=0,bidirectional=False):\n",
    "        super(LSTM,self).__init__()\n",
    "        self.input_size=input_size\n",
    "        self.hidden_size=hidden_size\n",
    "        self.num_layers=num_layers\n",
    "        self.dropout=dropout\n",
    "        self.bidirectional=bidirectional\n",
    "        self.lstm = nn.LSTM(input_size,\n",
    "                            hidden_size,\n",
    "                            num_layers,\n",
    "                            dropout=dropout,\n",
    "                            bidirectional=bidirectional)\n",
    "        self.linear = nn.Linear(hidden_size, input_size)\n",
    "        \n",
    "    def forward(self,inputs,hidden):\n",
    "        outputs,hidden=self.lstm(inputs,hidden)\n",
    "        predictions=self.linear(outputs[-1:])\n",
    "        return predictions,outputs,hidden\n",
    "    \n",
    "    def init_hidden(self,batch_size):\n",
    "        num_directions=2 if self.bidirectional else 1\n",
    "        hidden = (torch.zeros(self.num_layers*num_directions, batch_size, self.hidden_size),\n",
    "                  torch.zeros(self.num_layers*num_directions, batch_size, self.hidden_size))\n",
    "        return hidden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_batch(x,y,i,batch_size):\n",
    "    if x.dim() == 2:\n",
    "        x = x.unsqueeze(2)\n",
    "    batch_x = x[(i*batch_size):(i*batch_size)+batch_size, :, :]\n",
    "    batch_y = y[(i*batch_size):(i*batch_size)+batch_size]\n",
    "\n",
    "    # Reshape Tensors into (seq_len, batch_size, input_size) format for the LSTM.\n",
    "    batch_x = batch_x.transpose(0, 1)\n",
    "    batch_y = batch_y.transpose(0,1)\n",
    "    \n",
    "    return batch_x, batch_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model,x_train_set,y_train_set,optimizer,batch_size,epoch):\n",
    "    num_sequences=x_train_set.size(0)\n",
    "    num_batches=num_sequences//batch_size\n",
    "    \n",
    "    total_loss=0\n",
    "    \n",
    "    model.train()\n",
    "    for i in range(num_batches):\n",
    "        # Get input and target batches and reshape for LSTM.\n",
    "        batch_x, batch_y = get_batch(x_train_set, y_train_set, i, batch_size)\n",
    "\n",
    "        # Reset the gradient.\n",
    "        lstm.zero_grad()\n",
    "        \n",
    "        # Initialize the hidden states (see the function lstm.init_hidden(batch_size)).\n",
    "        hidden = lstm.init_hidden(batch_size)\n",
    "        \n",
    "        # Complete a forward pass.\n",
    "        y_pred, outputs, hidden = lstm(batch_x,hidden)\n",
    "        \n",
    "        # Calculate the loss with the 'loss_fn'.\n",
    "        loss = loss_fn(y_pred,batch_y)\n",
    "        \n",
    "        # Compute the gradient.\n",
    "        loss.backward()\n",
    "        \n",
    "        # Clip to the gradient to avoid exploding gradient.\n",
    "        nn.utils.clip_grad_norm_(lstm.parameters(), max_grad_norm)\n",
    "\n",
    "        # Make one step with optimizer.\n",
    "        optimizer.step()\n",
    "        \n",
    "        # Accumulate the total loss.\n",
    "        total_loss += loss.data\n",
    "        \n",
    "    print(\"Epoch {}: Loss = {:.8f}\".format(epoch+1, total_loss/num_batches))\n",
    "    return total_loss/num_batches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval(model,x_valid_set,y_valid_set,optimizer,batch_size):\n",
    "    num_sequences=x_valid_set.size(0)\n",
    "    num_batches=num_sequences//batch_size\n",
    "    \n",
    "    total_loss=0\n",
    "    \n",
    "    model.eval()\n",
    "    for i in range(num_batches):\n",
    "        # Get input and target batches and reshape for LSTM.\n",
    "        batch_x, batch_y = get_batch(x_valid_set, y_valid_set, i, batch_size)\n",
    "\n",
    "        # Reset the gradient.\n",
    "        lstm.zero_grad()\n",
    "        \n",
    "        # Initialize the hidden states (see the function lstm.init_hidden(batch_size)).\n",
    "        hidden = lstm.init_hidden(batch_size)\n",
    "        \n",
    "        # Complete a forward pass.\n",
    "        y_pred, outputs, hidden = lstm(batch_x,hidden)\n",
    "        \n",
    "        # Calculate the loss with the 'loss_fn'.\n",
    "        loss = loss_fn(y_pred,batch_y)\n",
    "        \n",
    "        # Compute the gradient.\n",
    "        loss.backward()\n",
    "        \n",
    "        # Clip to the gradient to avoid exploding gradient.\n",
    "        nn.utils.clip_grad_norm_(lstm.parameters(), max_grad_norm)\n",
    "\n",
    "        # Make one step with optimizer.\n",
    "        optimizer.step()\n",
    "        \n",
    "        # Accumulate the total loss.\n",
    "        total_loss += loss.data\n",
    "\n",
    "    print(\"Validation: Loss = {:.8f}\".format(total_loss/num_batches))\n",
    "    return total_loss/num_batches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_model(epoch, model, path='./'):\n",
    "    \n",
    "    # file name and path \n",
    "    filename = path + 'toronto.pt'\n",
    "    \n",
    "    # load the model parameters \n",
    "    torch.save(model.state_dict(), filename)\n",
    "    \n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_model(city, model, path='./'):\n",
    "    \n",
    "    # file name and path \n",
    "    filename = path + '{}.pt'.format(city)\n",
    "    \n",
    "    # load the model parameters \n",
    "    model.load_state_dict(torch.load(filename))\n",
    "    \n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training model for 40 epoch\n",
      "Epoch 1: Loss = 0.02875476\n",
      "Validation: Loss = 0.01399143\n",
      "Epoch 2: Loss = 0.00950872\n",
      "Validation: Loss = 0.00870981\n",
      "Epoch 3: Loss = 0.00730255\n",
      "Validation: Loss = 0.00699581\n",
      "Epoch 4: Loss = 0.00620711\n",
      "Validation: Loss = 0.00608072\n",
      "Epoch 5: Loss = 0.00570191\n",
      "Validation: Loss = 0.00573658\n",
      "Epoch 6: Loss = 0.00545097\n",
      "Validation: Loss = 0.00545945\n",
      "Epoch 7: Loss = 0.00528087\n",
      "Validation: Loss = 0.00507464\n",
      "Epoch 8: Loss = 0.00515113\n",
      "Validation: Loss = 0.00491360\n",
      "Epoch 9: Loss = 0.00501603\n",
      "Validation: Loss = 0.00487238\n",
      "Epoch 10: Loss = 0.00501465\n",
      "Validation: Loss = 0.00479590\n",
      "Epoch 11: Loss = 0.00494306\n",
      "Validation: Loss = 0.00462293\n",
      "Epoch 12: Loss = 0.00489777\n",
      "Validation: Loss = 0.00462129\n",
      "Epoch 13: Loss = 0.00488167\n",
      "Validation: Loss = 0.00462213\n",
      "Epoch 14: Loss = 0.00483084\n",
      "Validation: Loss = 0.00447974\n",
      "Epoch 15: Loss = 0.00482029\n",
      "Validation: Loss = 0.00440030\n",
      "Epoch 16: Loss = 0.00479621\n",
      "Validation: Loss = 0.00450575\n",
      "Epoch 17: Loss = 0.00478776\n",
      "Validation: Loss = 0.00441606\n",
      "Epoch 18: Loss = 0.00476521\n",
      "Validation: Loss = 0.00435126\n",
      "Epoch 19: Loss = 0.00474524\n",
      "Validation: Loss = 0.00434483\n",
      "Epoch 20: Loss = 0.00473557\n",
      "Validation: Loss = 0.00436581\n",
      "Epoch 21: Loss = 0.00472710\n",
      "Validation: Loss = 0.00433492\n",
      "Epoch 22: Loss = 0.00472391\n",
      "Validation: Loss = 0.00430711\n",
      "Epoch 23: Loss = 0.00471692\n",
      "Validation: Loss = 0.00429709\n",
      "Epoch 24: Loss = 0.00471471\n",
      "Validation: Loss = 0.00426438\n",
      "Epoch 25: Loss = 0.00469651\n",
      "Validation: Loss = 0.00417337\n",
      "Epoch 26: Loss = 0.00470320\n",
      "Validation: Loss = 0.00426309\n",
      "Epoch 27: Loss = 0.00468224\n",
      "Validation: Loss = 0.00417613\n",
      "Epoch 28: Loss = 0.00467001\n",
      "Validation: Loss = 0.00425440\n",
      "Epoch 29: Loss = 0.00467350\n",
      "Validation: Loss = 0.00417929\n",
      "Epoch 30: Loss = 0.00464733\n",
      "Validation: Loss = 0.00420871\n",
      "Epoch 31: Loss = 0.00465530\n",
      "Validation: Loss = 0.00413783\n",
      "Epoch 32: Loss = 0.00465774\n",
      "Validation: Loss = 0.00407769\n",
      "Epoch 33: Loss = 0.00465195\n",
      "Validation: Loss = 0.00415043\n",
      "Epoch 34: Loss = 0.00465303\n",
      "Validation: Loss = 0.00407488\n",
      "Epoch 35: Loss = 0.00464726\n",
      "Validation: Loss = 0.00418405\n",
      "Epoch 36: Loss = 0.00463594\n",
      "Validation: Loss = 0.00410177\n",
      "Epoch 37: Loss = 0.00463547\n",
      "Validation: Loss = 0.00409317\n",
      "Epoch 38: Loss = 0.00463291\n",
      "Validation: Loss = 0.00408201\n",
      "Epoch 39: Loss = 0.00460706\n",
      "Validation: Loss = 0.00407426\n",
      "Epoch 40: Loss = 0.00462362\n",
      "Validation: Loss = 0.00410298\n",
      "\n",
      "\n",
      "\n",
      "Optimization ended.\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "input_size=13\n",
    "hidden_size=24\n",
    "num_layers=2\n",
    "lstm=LSTM(input_size,hidden_size)\n",
    "\n",
    "learning_rate=0.001\n",
    "max_grad_norm=5\n",
    "loss_fn = nn.MSELoss()\n",
    "optimizer = optim.Adam(lstm.parameters(), lr=learning_rate,weight_decay=0.00001)\n",
    "\n",
    "batch_size = 8\n",
    "num_epochs = 40 #3\n",
    "# num_sequences = x_train_set.size(0)\n",
    "# num_batches = num_sequences //batch_size\n",
    "\n",
    "checkpoint_freq = 10\n",
    "path = './'\n",
    "\n",
    "train_losses=[]\n",
    "valid_losses=[]\n",
    "\n",
    "print(\"Training model for {} epoch\".format(num_epochs))\n",
    "for epoch in range(num_epochs):\n",
    "#     total_loss = 0\n",
    "\n",
    "    # Shuffle input and target sequences.\n",
    "    idx = torch.randperm(x_train_set.size(0))\n",
    "    x_shuffled = x_train_set[idx]\n",
    "    y_shuffled = y_train_set[idx]\n",
    "    \n",
    "    train_loss=train(lstm,x_shuffled,y_shuffled,optimizer,batch_size,epoch)\n",
    "    valid_loss=eval(lstm,x_valid_set,y_valid_set,optimizer,batch_size)\n",
    "    \n",
    "    train_losses.append(train_loss)\n",
    "    valid_losses.append(valid_loss)\n",
    "    \n",
    "    # Checkpoint\n",
    "    if epoch % checkpoint_freq ==0:\n",
    "        save_model(epoch, lstm, path)\n",
    "        \n",
    "# Last checkpoint\n",
    "save_model(num_epochs, lstm, path)\n",
    "    \n",
    "print(\"\\n\\n\\nOptimization ended.\\n\")\n",
    "\n",
    "plt.plot(train_losses, color=\"darkcyan\", label=\"train\")\n",
    "plt.plot(valid_losses, color=\"tomato\",label=\"validation\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_size=13\n",
    "hidden_size=24\n",
    "num_layers=2\n",
    "lstm=LSTM(input_size,hidden_size)\n",
    "\n",
    "learning_rate=0.001\n",
    "max_grad_norm=5\n",
    "loss_fn = nn.MSELoss()\n",
    "optimizer = optim.Adam(lstm.parameters(), lr=learning_rate,weight_decay=0.00001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "lstm=load_model('toronto',lstm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_one_hour(model,x_valid_set,input_size,num_steps,scaler,y_valid_set,loss_fn):\n",
    "    total_loss=0\n",
    "    predictions=torch.zeros(num_steps)\n",
    "    for i, x in enumerate(x_valid_set):\n",
    "        hidden=model.init_hidden(1)\n",
    "        y_pred,_,_=model(x.contiguous().view(-1, 1, input_size),hidden)\n",
    "#         print(y_pred.shape)\n",
    "        predictions[i]=torch.FloatTensor(scaler.inverse_transform(y_pred[0].data)[:,-1])\n",
    "        loss=loss_fn(y_pred.squeeze(1),y_valid_set[i])\n",
    "        total_loss+=loss\n",
    "    return predictions,total_loss/num_steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_fn=nn.MSELoss()\n",
    "one_step_predictions,loss = predict_one_hour(lstm, x_test_set, input_size, y_test_set.size(0),scaler,y_test_set,loss_fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.1864076\n",
      "1465.167\n"
     ]
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(14, 10))\n",
    "plt.plot(y_test_set[:,0,-1].data.numpy(),color='darkcyan')\n",
    "plt.plot(one_step_predictions.data.numpy(),color='tomato')\n",
    "plt.show()\n",
    "\n",
    "print(loss_fn(one_step_predictions,y_test_set[:,0,-1]).data.numpy())\n",
    "print(loss.data.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 24hours model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
